# -*- coding: Latin-1 -*-
#!/usr/bin/env python
'''
Created on 24/11/2011

@author: nmedina
'''
import Excepciones
import types
import Seguridad
import sys
import WebServices.soap
import Funciones.Fn
class Articulo_caracteristica():
    def __init__(self):
        self.__id = -1
        self.__Descripcion = ""
        self.__Valor = ""
    def getId(self):
        return self.__id
    def getDescripcion(self):
        return self.__Descripcion
    def getValor(self):
        return self.__Valor
    def setId(self, value):
        self.__id = value.strip()
    def setDescripcion(self, value):
        self.__Descripcion = value.strip()
    def setValor(self, value):
        self.__Valor = value.strip()
    def clear(self):
        self.__id = -1
        self.__Descripcion = ""
        self.__Valor = ""

class Caracteristica_Invalida(Exception):
    """Excepcion: ocurre cuando hay problemas con el manejo de las caracteristicas
    Parametros:
    -mensaje: mensaje de error"""
    def __init__(self,mensaje):
        self.__Mensaje = mensaje
        self.__ErrorDescripcion = self.__Mensaje
    def __str__(self):
        return repr(self.__ErrorDescripcion)
    
    
class Articulo_base():
    def __init__(self):
        self.__IdArticulo = -1
        self.__IdTipoArticulo = -1
        self.__TipoArticuloDescripcion = ""
        self.__IdFabricante = -1
        self.__NombreFabricante = ""
        self.__Modelo = ""
        self.__RequiereNroSerie = False
        self.__RequiereAutorizacion = False
        self.__Descripcion = ""
        self.__Caracteristicas = {}
    def getIdArticulo(self):
        return self.__IdArticulo
    def getIdTipoArticulo(self):
        return self.__IdTipoArticulo
    def getTipoArticuloDescripcion(self):
        return self.__TipoArticuloDescripcion
    def getIdFabricante(self):
        return self.__IdFabricante
    def getNombreFabricante(self):
        return self.__NombreFabricante
    def getModelo(self):
        return self.__Modelo
    def getRequiereNroSerie(self,lbool = True):
        if lbool == True:
            return self.__RequiereNroSerie
        else:
            if self.__RequiereNroSerie == True:
                return "1"
            else:
                return "0"
    def getRequiereAutorizacion(self,lbool = True):
        if lbool == True:
            return self.__RequiereAutorizacion
        else:
            if self.__RequiereAutorizacion == True:
                return "1"
            else:
                return "0"
    def getDescripcion(self):
        return self.__Descripcion
    def getCaracteristicas(self):
        return self.__Caracteristicas
    def getCaracteristica_listado_lv(self):
        dicc = {}
        caracteristica = Articulo_caracteristica()
        for key in self.__Caracteristicas:
            caracteristica = self.__Caracteristicas[key]
            dicc[caracteristica.getId()]= (caracteristica.getDescripcion(),caracteristica.getValor())
        return dicc
    def getCaracteristicas_count(self):
        return len(self.__Caracteristicas)
    def setIdArticulo(self, value):
        self.__IdArticulo = value
    def setIdTipoArticulo(self, value):
        self.__IdTipoArticulo = value
    def setTipoArticuloDescripcion(self, value):
        self.__TipoArticuloDescripcion = value
    def setIdFabricante(self, value):
        self.__IdFabricante = value
    def setNombreFabricante(self, value):
        self.__NombreFabricante = value
    def setModelo(self, value):
        self.__Modelo = value
    def setRequiereNroSerie(self, value):
        if value == 'True' or value == True:
            self.__RequiereNroSerie = True
        else:
            self.__RequiereNroSerie = False
    def setRequiereAutorizacion(self, value):
        if value == 'True' or value == True:
            self.__RequiereAutorizacion = True
        else:
            self.__RequiereAutorizacion = False
    def setDescripcion(self, value):
        self.__Descripcion = value
    def Caracteristica_Editar(self,lcacteristica):
        if isinstance(lcacteristica, Articulo_caracteristica)== True:
            caracteristica = Articulo_caracteristica()
            caracteristica = lcacteristica
            if self.__Caracteristicas.has_key(caracteristica.getId())== True:
                self.__Caracteristicas[caracteristica.getId()] = caracteristica
            else:
                raise Caracteristica_Invalida("Caracteristica no encontrada")
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "Articulo_base"
                  , "Caracteristica_Editar"
                  , "Se esperaba dato del tipo caracteristica")
    def Caracteristica_Eliminar(self,lid):
        if self.__Caracteristicas.has_key(lid)== True:
            del self.__Caracteristicas[lid]
        else:
            raise Caracteristica_Invalida("Caracteristica no encontrada")
    def Caracteristica_Agregar(self,lcacteristica):
        if isinstance(lcacteristica, Articulo_caracteristica)== True:
            caracteristica = Articulo_caracteristica()
            caracteristica = lcacteristica
            if self.__Caracteristicas.has_key(caracteristica.getId())== False:
                self.__Caracteristicas[caracteristica.getId()]= caracteristica
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion("Articulo_base"
                                                                       , "Caracteristica_Agregar"
                                                                       , "La caracteristica ya fue asignada")
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "Articulo_base"
                  , "Caracteristica_Agregar"
                  , "Se esperaba dato del tipo caracteristica")
    def clear(self):
        self.__IdArticulo = -1
        self.__IdTipoArticulo = -1
        self.__TipoArticuloDescripcion = ""
        self.__IdFabricante = -1
        self.__NombreFabricante = ""
        self.__Modelo = ""
        self.__RequiereNroSerie = False
        self.__RequiereAutorizacion = False
        self.__Descripcion = ""
        self.__Caracteristicas = {}
    

        
class Articulo_Ingreso_Edicion():
    def __init__(self,lsecurity):
        self.__security = Seguridad.seguridadstock.Manejador()
        self.__security = lsecurity
        self.articulo = Articulo_base()
        self.articulo.clear()
             
    def __Crear_xml_nuevo_articulo(self):
        caracteristica = Articulo_caracteristica()
        self.__xml_nuevo_articulo = WebServices.soap.XmlStored("AltaArticulo")
        self.__xml_nuevo_articulo.AddNodoHijo("DetalleArticulo", self.__Get_dicc_detalle_articulo())
        listado = self.articulo.getCaracteristicas() 
        for key in listado:
            caracteristica = listado[key]
            dict = {1:{"Name":"Caracteristica","Value" :str(caracteristica.getId())}
                    ,2:{"Name":"Valor","Value" :str(caracteristica.getValor())}}
            self.__xml_nuevo_articulo.AddNodoHijo("Caracteristicas", dict)
        
        return self.__xml_nuevo_articulo.GetToXml()
         

    def __Get_dicc_detalle_articulo(self):
        dict = {1:{"Name":"IDTipoArticulo","Value" :str(self.articulo.getIdTipoArticulo())}
                ,2:{"Name":"IDFabricante","Value" :str(self.articulo.getIdFabricante())}
                ,3:{"Name":"Modelo","Value" :str(self.articulo.getModelo())}
                ,4:{"Name":"Descripcion","Value" :str(self.articulo.getDescripcion())}
                ,5:{"Name":"RequiereAutorizacion","Value" : self.articulo.getRequiereAutorizacion(False)}
                ,6:{"Name":"RequiereNroSerie","Value" :self.articulo.getRequiereNroSerie(False)}
                ,7:{"Name":"IDUsuario","Value" : str(self.__security.getIdUsuario())}}
        return dict
    def Articulo_agregar_nuevo(self):
        WebService = WebServices.soap.WebService(
                        self.__security.getUrlServidorWeb()
                        , self.__security.getHostServidorWeb()
                        , self.__security.getProxy()
                        , self.__security.getTipoServidor()
                        ,self.__security.getReintentos())
            
        Parametros = {1:('XMLDOC',str(self.__Crear_xml_nuevo_articulo()))
                            ,2:('TipoRespuesta','Python')}
            
        if WebService.Enviar( 'INSERT_XML_AltaArticulo'
                              ,'www.osplad.org.ar',
                            Parametros) == True:
            pass
        
        
    def __Crear_xml_editar_articulo(self):
        caracteristica = Articulo_caracteristica()
        __xml_editar_articulo = WebServices.soap.XmlStored("EdicionArticulo")
        __xml_editar_articulo.AddNodoHijo("EdicionDetalleArticulo", self.__Get_dicc_Edicion_detalle_articulo())
        listado = self.articulo.getCaracteristicas() 
        for key in listado:
            caracteristica = listado[key]
            dict = {1:{"Name":"Caracteristica","Value" :str(caracteristica.getId())}
                    ,2:{"Name":"Valor","Value" :str(caracteristica.getDescripcion())}}
            __xml_editar_articulo.AddNodoHijo("Caracteristicas", dict)
          
        return __xml_editar_articulo.GetToXml()
            
            
    def __Get_dicc_Edicion_detalle_articulo(self):
        dict = {1:{"Name":"IDArticulo","Value" :str(self.articulo.getIdArticulo())}
                ,2:{"Name":"IDFabricante","Value" :str(self.articulo.getIdFabricante())}
                ,3:{"Name":"Modelo","Value" :str(self.articulo.getModelo())}
                ,4:{"Name":"Descripcion","Value" :str(self.articulo.getDescripcion())}
                ,5:{"Name":"RequiereAutorizacion","Value" :self.articulo.getRequiereAutorizacion(False)}
                ,6:{"Name":"RequiereNroSerie","Value" :self.articulo.getRequiereNroSerie(False)}
                ,7:{"Name":"IDUsuario","Value" : str(self.__security.getIdUsuario())}}
        return dict
    def Articulo_Editar(self):
        WebService = Funciones.WebService(
                    self.__Seg.getUrlServidorWeb()
                    , self.__Seg.getHostServidorWeb()
                    , self.__Seg.getProxy()
                    , self.__Seg.getTipoServidor()
                    ,self.__Seg.getReintentos())
            
        Parametros = {1:('XMLDOC',str(self.__Crear_xml_editar_articulo()))
                            ,2:('TipoRespuesta','Python')}
            
            
        if WebService.Enviar( 'UPDATE_XML_EditarArticulo'
                                ,'www.osplad.org.ar',
                                Parametros) == True:
            pass
                
        
            
            
    def Articulo_traer(self,IdArticulo):
        self.articulo.clear()
        Parametros = {1:('IdArticulo',str(IdArticulo))
                          ,2:("IdGrupoStock",str(self.__Seg.GetPerfilActual()))
                          ,3:('TipoRespuesta','Python')}
            
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())
            
        if WebService.Enviar('SELECT_ArticulosXId'
                                 ,'www.osplad.org.ar'
                                 ,Parametros) == True:
            if WebService.Count()!= 0:
                while WebService.BOF()!= True and WebService.EOF()!= True:
                    self.articulo.setIdArticulo(WebService.Fields('ID_Articulo'))
                    self.articulo.setIdFabricante(WebService.Fields('ID_Fabricante'))
                    self.articulo.setNombreFabricante(WebService.Fields('Fabricante'))
                    self.articulo.setIdTipoArticulo(WebService.Fields('ID_TipoArticulo'))
                    self.articulo.setTipoArticuloDescripcion(WebService.Fields('TipoArticulo'))
                    self.articulo.setModelo(WebService.Fields('Modelo'))
                    self.articulo.setDescripcion(WebService.Fields('Descripcion'))
                    self.articulo.setRequiereNroSerie(WebService.Fields('TieneNroSerie'))
                    self.articulo.setRequiereAutorizacion(WebService.Fields('RequiereAutorizacion'))
                    WebService.MoveNext()
                if self.TraerCaracteristicasDelArticulo(IdArticulo) == True:
                    return True
                else:
                    return False
            else:
                raise Excepciones.Genericas.Consulta_Sin_Resultados(
                        "Articulo_Ingreso_Edicion"
                        , "Articulo_traer"
                        , "No se encotro el articulo")
            
        
    def Articulo_traer_caracteristicas(self,IdArticulo):
       Parametros = {1:('IdArticulo',str(IdArticulo))
                        ,2:('TipoRespuesta','Python')}
            
       WebService = WebServices.soap.WebService(
                     self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    ,self.__security.getReintentos())
       if WebService.Enviar('SELECT_CaracteristicasDeArticulosXId'
                                ,'www.osplad.org.ar'
                                ,Parametros) == True:
           if WebService.Count()!= 0:
                while WebService.BOF() != True and WebService.EOF() != True:
                    caracteristica = Articulo_caracteristica()
                    caracteristica.setId(WebService.Fields("ID_CARACTERISTICA"))
                    caracteristica.setDescripcion(WebService.Fields("CARACTERISTICA"))
                    caracteristica.setValor(WebService.Fields("VALOR"))
                    self.articulo.Caracteristica_Agregar(caracteristica)
                    WebService.MoveNext()
                return True
           else:
                raise Excepciones.Genericas.Consulta_Sin_Resultados(
                    "Articulo_Ingreso_Edicion"
                    , "Articulo_traer_caracteristicas"
                    , "No se encotraron caracteristicas")
    
    
        
    
class Fabricante_base():
    def __init__(self,lid=-1,lnombre = "",ldescripcion = ""):
        self.__Id = lid       
        self.__Nombre = lnombre
        self.__Descripcion = ldescripcion
    def getId(self):
        return self.__Id
    def getNombre(self):
        return self.__Nombre
    def getDescripcion(self):
        return self.__Descripcion
    def setId(self, value):
        self.__Id = value
    def setNombre(self, value):
        self.__Nombre = value
    def setDescripcion(self, value):
        self.__Descripcion = value

        
class Fabricante_Alta_modificacion(Fabricante_base):   
    def __init__(self,lsecurity):
        Fabricante_base.__init__(self)
        self.__security = lsecurity
    def alta(self):
        WebService = WebServices.soap.WebService(
                     self.__security.getUrlServidorWeb()
                     , self.__security.getHostServidorWeb()
                     , self.__security.getProxy()
                     , self.__security.getTipoServidor()
                     , self.__security.getReintentos())
        parametros = {1:("Nombre",str(self.getNombre()))
                      ,2:("Descripcion",str(self.getDescripcion()))
                      ,3:("TipoRespuesta",str("Python"))}
        if WebService.Enviar(
            "INSERT_NuevoFabricante"
            , "www.osplad.org.ar"
            , parametros, "Python")== True:
            pass
class FacturaBase():
    def __init__(self):
        self.__IdProveedor = -1
        self.__Nombre = ""
        self.__Cuil = ""
        self.__NroFactura = ""
        self.__FechaFactura = ""
        self.__TiempoGarantia = ""
        self.__IdUnidadGarantia = ""
        self.__Precio = 0
    def getPrecio(self):
        return self.__Precio
    def setPrecio(self, value):
        self.__Precio = value
    def getIdProveedor(self):
        return self.__IdProveedor
    def getNombre(self):
        return self.__Nombre
    def getCuil(self):
        return self.__Cuil
    def getNroFactura(self):
        return self.__NroFactura
    def getFechaFactura(self):
        return self.__FechaFactura
    def getTiempoGarantia(self):
        return self.__TiempoGarantia
    def getIdUnidadGarantia(self):
        return self.__IdUnidadGarantia
    def setIdProveedor(self, value):
        self.__IdProveedor = value
    def setNombre(self,value):
        self.__Nombre = value
    def setCuil(self,value):
        self.__Cuil = value
    def setNroFactura(self, value):
        self.__NroFactura = value
    def setFechaFactura(self, value):
        self.__FechaFactura = value
    def setTiempoGarantia(self, value):
        self.__TiempoGarantia = value
    def setIdUnidadGarantia(self, value):
        self.__IdUnidadGarantia = value
    def LimpiarFactura(self):
        self.__IdProveedor = -1
        self.__NroFactura = ""
        self.__FechaFactura = ""
        self.__TiempoGarantia = ""
        self.__IdUnidadGarantia = ""
class ArticuloDistribuido():
    def __init__(self):
        self.__IdGrupo = -1
        self.__IdArticulo = -1
        self.__IdDeposito = -1
        self.__DescripcionDeposito = ""
        self.__Cantidad = 0
    def getDescripcionDeposito(self):
        return self.__DescripcionDeposito
    def setDescripcionDeposito(self, value):
        self.__DescripcionDeposito = value
    def getIdGrupo(self):
        return self.__IdGrupo
    def getIdArticulo(self):
        return self.__IdArticulo
    def getIdDeposito(self):
        return self.__IdDeposito
    def getCantidad(self):
        return self.__Cantidad
    def setIdGrupo(self, value):
        self.__IdGrupo = value
    def setIdArticulo(self, value):
        self.__IdArticulo = value
    def setIdDeposito(self, value):
        self.__IdDeposito = value
    def setCantidad(self, value):
        self.__Cantidad = value
        
        
class ArticulosNroSeries():
    def __init__(self):
        self.__IdGrupo = -1
        self.__IdArticulo = -1
        self.__NroSerie = ""
        self.__Verificada = "No"
    def getIdGrupo(self):
        return self.__IdGrupo
    def getIdArticulo(self):
        return self.__IdArticulo
    def setIdGrupo(self, value):
        self.__IdGrupo = value
    def setIdArticulo(self, value):
        self.__IdArticulo = value
    def getNroSerie(self):
        return self.__NroSerie
    def getVerificada(self):
        return self.__Verificada
    def setNroSerie(self, value):
        self.__NroSerie = value
    def setVerificada(self, value):
        self.__Verificada = value

class NroSeriesBase():
    def __init__(self,lsecurity):
        self.__NroSeries = {} 
        if isinstance(lsecurity,Seguridad.seguridadstock.Manejador)== True:
            self.__security = Seguridad.seguridadstock.Manejador()
            self.__security = lsecurity
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "NroSeriesBase"
                  , "__init__"
                  , "Se esperaba clase Seguridad.seguridadstock.Manejador")  
    def _getNroSeries(self):
        return self.__NroSeries
    def _AgregarNroSeries(self,mIdArticulo,mNroSerie):
        if type(mIdArticulo)== types.IntType and type(mNroSerie) == types.StringType:
            mNroSerie = mNroSerie.strip()
            lNro = ArticulosNroSeries()
            if self.__NroSeries.has_key(mNroSerie)== False:
                lNro.setIdArticulo(mIdArticulo)
                lNro.setIdGrupo(self.__security.getPerfilActual())
                lNro.setNroSerie(mNroSerie)
                lNro.setVerificada("No")
                self.__NroSeries[lNro.getNroSerie()]= lNro
            else:
                 raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "NroSeriesBase"
                  , "AgregarNroSeries"
                  , "El nro de serie ya fue ingresado")
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "NroSeriesBase"
                  , "AgregarNroSeries"
                  , "Parametros incorrectos: mIdArticulo debe ser entero y mNroSerie string")
    def _EliminarNroSerie(self,mNroSerie):
        if type(mNroSerie)== types.StringType:
            mNroSerie = mNroSerie.strip()
            if self.__NroSeries.has_key(mNroSerie)== True:
                del self.__NroSeries[mNroSerie]
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "NroSeriesBase"
                  , "AgregarNroSeries"
                  , "No se encontro el nro de serie")
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "NroSeriesBase"
                  , "AgregarNroSeries"
                  , "Parametros incorrectos:  mNroSerie string")
    def _Editar_Validacion_Nro_Serie(self,lNroserie,lvalido):
        lNro = ArticulosNroSeries()
        if self.__NroSeries.has_key(lNroserie)== True:
            lNro = self.__NroSeries[lNroserie]
            lNro.setVerificada(lvalido)
            self.__NroSeries[lNroserie]= lNro
        else:
            raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                        "NroSeriesBase"
                        , "AgregarNroSeries"
                        , "No se encontro el nro de serie")
    def _Son_Validos_Los_Nro_Series(self):
        for key in self.__NroSeries:
            if self.__NroSeries[key].getVerificada()== "Invalido":
                return False
        return True
    def _Borrar_Todos_Los_Nro_De_Series(self):
        self.__NroSeries.clear()
       
class DistribucionStockBase():
    def __init__(self,lsecurity):
        self.__Distribucion = {}
        if isinstance(lsecurity,Seguridad.seguridadstock.Manejador)== True:
            self.__security = Seguridad.seguridadstock.Manejador()
            self.__security = lsecurity
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "DistribucionStockBase"
                  , "__init__"
                  , "Se esperaba clase Seguridad.seguridadstock.Manejador")

    def _getDistribucion(self):
        return self.__Distribucion
    
    def _AgregarDistribucion(self,mIdDeposito,mDescripcionDeposito,mIdArticulo,mCantidad):
        if type(mIdDeposito)== types.IntType and type(mCantidad)== types.IntType and type(mIdArticulo)== types.IntType:  
            if mCantidad > 0 :
                lArticuloDistribuido = ArticuloDistribuido()
                if self.__Distribucion.has_key(mIdDeposito)== True:
                    lArticuloDistribuido = self.__Distribucion[mIdDeposito]
                    lArticuloDistribuido.setCantidad(mCantidad + lArticuloDistribuido.getCantidad())
                    del self.__Distribucion[mIdDeposito]
                    self.__Distribucion[lArticuloDistribuido.getIdDeposito()]= lArticuloDistribuido
                else:
                    lArticuloDistribuido.setIdDeposito(mIdDeposito)
                    lArticuloDistribuido.setCantidad(mCantidad)
                    lArticuloDistribuido.setIdGrupo(self.__security.getPerfilActual())
                    lArticuloDistribuido.setIdArticulo(mIdArticulo)
                    lArticuloDistribuido.setDescripcionDeposito(mDescripcionDeposito)
                    self.__Distribucion[lArticuloDistribuido.getIdDeposito()]= lArticuloDistribuido
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "DistribucionStockBase"
                  , "AgregarDistribucion"
                  , "La cantidad a distribuir no puede ser 0") 
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "DistribucionStockBase"
                  , "AgregarDistribucion"
                  , "Parametros incorrectos: los parametros deben ser enteros")
    def _EliminarDistribucion(self,mIdDeposito):
        if type(mIdDeposito) == types.IntType:
            if self.__Distribucion.has_key(mIdDeposito)== True:
                del self.__Distribucion[mIdDeposito]
            else:
                raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "DistribucionStockBase"
                  , "EliminarDistribucion"
                  , "Deposito no encontrado: No se pudo eliminae la distribucion")
        else:
            raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "DistribucionStockBase"
                  , "EliminarDistribucion"
                  , "Parametros incorrectos: los parametros deben ser enteros") 
    def _Borrar_Todas_Las_Distribuciones(self):
        self.__Distribucion.clear()
                 
class IngresoDeArticulosCompras(FacturaBase
                         ,NroSeriesBase
                         ,DistribucionStockBase):
    def __init__(self,lsecurity):
        if isinstance(lsecurity,Seguridad.seguridadstock.Manejador)== True:
            self.__security = lsecurity
        else:
           raise Excepciones.Genericas.Generico_Parametros_Incorrectos(
                  "IngresoDeArticulosCompras"
                  , "__init__"
                  , "Se esperaba clase Seguridad.seguridadstock.Manejador") 
    
        FacturaBase.__init__(self)
        NroSeriesBase.__init__(self, self.__security)
        DistribucionStockBase.__init__(self, self.__security)
        self.__FG = Funciones.Fn.FuncionesGenerales()
        self.__IdTipoIngreso = -1
        self.__IdGrupo = self.__security.getPerfilActual()
        self.__IdArticulo = -1
        self.__Fabricante = ""
        self.__Tipo = ""
        self.__Modelo = ""
        self.__Cantidad = 1
        self.__StockMinimo = 0
        self.__PedirNroSeries = False
        self.__xml = ""
        self.__IdMovimiento = -1
    def getIdMovimiento(self):
        return self.__IdMovimiento
    def getPedirNroSeries(self):
        return self.__PedirNroSeries
    def getIdTipoIngreso(self):
        return self.__IdTipoIngreso
    def getIdGrupo(self):
        return self.__IdGrupo
    def getIdArticulo(self):
        return self.__IdArticulo
    def getFabricante(self):
        return self.__Fabricante
    def getTipo(self):
        return self.__Tipo
    def getModelo(self):
        return self.__Modelo
    def getCantidad(self):
        return self.__Cantidad
    def getStockMinimo(self):
        return self.__StockMinimo
    def setPedirNroSeries(self, value):
        self.__PedirNroSeries = value
        if self.getPedirNroSeries()== False:
            self._Borrar_Todos_Los_Nro_De_Series()
    def setIdTipoIngreso(self, value):
        self.__IdTipoIngreso = value
    def setIdGrupo(self, value):
        self.__IdGrupo = value
    def setIdArticulo(self, value):
        self.__IdArticulo = value
    def setFabricante(self,value):
        self.__Fabricante = value
    def setTipo(self,value):
        self.__Tipo = value
    def setModelo(self,value):
        self.__Modelo = value
    def setCantidad(self, value):
        self.__Cantidad = value
    def setStockMinimo(self, value):
        self.__StockMinimo = value
    def LimpiarIngreso(self):
        self.__IdArticulo = -1
        self.__Cantidad = 1
        self.__StockMinimo = 0
        self.__PedirNroSeries = False
        self.__xml = ""
        self.__IdMovimiento = -1
    def AgregarDistribucion(self,mIdDeposito,mDescripcionDeposito
                            ,mIdArticulo,mCantidad):
        if (self.getCantidadDistribuida()+ mCantidad)<= self.getCantidad():
            self._AgregarDistribucion(mIdDeposito, mDescripcionDeposito
                                   , mIdArticulo, mCantidad)
        else:
            raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "IngresoDeArticulosCompras"
                  , "AgregarDistribucion"
                  , "La cantidad que intenta distribuir supera a la cantidad de articulos ingresados, verifique por favor")
    def EliminarDistribucion(self,mIdDeposito):
        self._EliminarDistribucion(mIdDeposito)
    def AgregarNroSeries(self,mIdArticulo,mNroSerie):
        if len(self._getNroSeries())< self.getCantidad():
            self._AgregarNroSeries(mIdArticulo, mNroSerie)
        else:
            raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "IngresoDeArticulosCompras"
                  , "AgregarNroSeries"
                  , "La cantidad de nro de series ingresados no puede superar a la cantidad de articulos")
    def EliminarNroSerie(self,mNroSerie):
        self._EliminarNroSerie(mNroSerie)
    def getListadoNroSeries(self):
        lseries = self._getNroSeries()
        mlistado = {}
        for key in lseries:
            lnro = ArticulosNroSeries()
            lnro = lseries[key]
            mlistado[lnro.getNroSerie()]= (lnro.getNroSerie(),lnro.getVerificada())
        return mlistado
    def getListadoDistribucion(self):
        ldistribucion = self._getDistribucion()
        mlistado = {}
        for key in ldistribucion:
            ldis = ArticuloDistribuido()
            ldis = ldistribucion[key]
            mlistado[ldis.getIdDeposito()]= (ldis.getDescripcionDeposito(),str(ldis.getCantidad()))
        return mlistado
    def getCantidadDistribuida(self):
        ldistribucion = self._getDistribucion()
        ltotal = 0
        for key in ldistribucion:
            ldis = ArticuloDistribuido()
            ldis = ldistribucion[key]
            ltotal = ltotal + int(ldis.getCantidad())
        return ltotal
    def __CrearXmlValidacion(self):
        try:
            self.__xml = "<NrosDeSeries>"
            self.__CrearNroSerieValidacion()
            self.__xml = self.__xml + "</NrosDeSeries>"
            return self.__xml
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.XmlErrorFormacion(str(error[1]))
    def __CrearNroSerieValidacion(self):
        lnro = ArticulosNroSeries()
        mNros = self._getNroSeries()
        for key in mNros :
           lnro = mNros[key]
           self.__xml = self.__xml + """<NroSerie>
        <IdArticulo>%s</IdArticulo>
        <Nro>%s</Nro>
    </NroSerie>""" % (self.getIdArticulo(),lnro.getNroSerie())
    def __CrearXmlAlta(self):
        try:
            self.__xml = "<AltaStock>"
            self.__CrearNodoDetalle()
            self.__CrearNodoDetalleFactura()
            self.__CrearNodoDetalleNroSerie()
            self.__CrearNodoDistribucion()
            self.__xml = self.__xml + "</AltaStock>"
            return self.__xml
        except:
            error = sys.exc_info()[:2]
            raise Excepciones.Genericas.XmlErrorFormacion(str(error[1]))
    def __CrearNodoDetalle(self):
        self.__xml = self.__xml + "<Detalle>"
        self.__xml = self.__xml + """<IdGrupo>%s</IdGrupo>
        <IdTipoIngreso>%s</IdTipoIngreso>
        <IdArticulo>%s</IdArticulo>
        <Cantidad>%s</Cantidad>
        <StockMinimo>%s</StockMinimo>
        <Precio>%s</Precio>
        <IdUsuario>%s</IdUsuario>""" % (self.getIdGrupo(),self.getIdTipoIngreso()
                                        ,self.getIdArticulo(),self.getCantidad(),self.getStockMinimo()
                                        ,self.getPrecio(),self.__security.getIdUsuario())
        self.__xml = self.__xml + "</Detalle>"
    def __CrearNodoDetalleFactura(self):
        self.__xml = self.__xml + """<DetalleFactura>
<IdArticulo>%s</IdArticulo>
<Nro>%s</Nro>
<IdProveedor>%s</IdProveedor>
<FechaCompra>%s</FechaCompra>
<TiempoGarantia>%s</TiempoGarantia>
<IdUnidadGarantia>%s</IdUnidadGarantia>
    </DetalleFactura>""" % (self.getIdArticulo(),self.getNroFactura()
                            ,self.getIdProveedor(),self.getFechaFactura()
                            ,self.getTiempoGarantia(),self.getIdUnidadGarantia())
    def __CrearNodoDetalleNroSerie(self):
        lnro = ArticulosNroSeries()
        mNros = self._getNroSeries()
        for key in mNros :
           lnro = mNros[key]
           self.__xml = self.__xml + """<DetalleNroSerie>
<IdGrupo>%s</IdGrupo>
<IdArticulo>%s</IdArticulo>
<NroSerie>%s</NroSerie>
</DetalleNroSerie>""" % (self.getIdGrupo(),self.getIdArticulo()
                         ,lnro.getNroSerie())
    def __CrearNodoDistribucion(self):
        ldis = ArticuloDistribuido()
        mDistribucion = self._getDistribucion()
        for key in mDistribucion:
            ldis = mDistribucion[key]
        self.__xml = self.__xml + """<Distribucion>
<IdGrupo>%s</IdGrupo>
<IdArticulo>%s</IdArticulo>
<IdDeposito>%s</IdDeposito>
<Cantidad>%s</Cantidad>
</Distribucion>""" % (self.getIdGrupo(),self.getIdArticulo()
                      ,ldis.getIdDeposito(),ldis.getCantidad())
    def __ValidarNroSeries(self):
        if len(self._getNroSeries())== self.getCantidad():
            pass
        else:
            raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                  "", "", "La cantidad de nro de series debe ser igual a la cantidad ingresada")
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    , self.__security.getReintentos())
        parametros = {1:("XMLDOC",self.__FG.Remplazar_Caracteres_Xml(self.__CrearXmlValidacion()))
                      ,2:("TipoRespuesta","Python")}
        
        if WebService.Enviar(
            "VALIDACIONES_NroSeriesCompras"
            , "www.osplad.org.ar"
            , parametros, "Python")== True:
            if WebService.Count()> 0 :
                while WebService.BOF()== False and WebService.EOF()== False:
                    self._Editar_Validacion_Nro_Serie(WebService.Fields("NroSerie").strip()
                                                      , WebService.Fields("Validacion"))
                    WebService.MoveNext()
            else:
                raise Excepciones.Genericas.Consulta_Sin_Resultados(
                        ""
                        , ""
                        , "VALIDACIONES_NroSeriesCompras: No se devolvieron resultados")
    def __ValidarDistribucion(self):
        if self.getCantidadDistribuida()== self.getCantidad():
            return True
        else:
            raise Excepciones.Genericas.Generico_ErrorDeValidacion(
                    ""
                    , ""
                    , "La cantidad de stock distribuida entre los depositos\nDebe ser igual a la cantidad ingresada")
    def __IngresarStock(self):
        WebService = WebServices.soap.WebService(
                    self.__security.getUrlServidorWeb()
                    , self.__security.getHostServidorWeb()
                    , self.__security.getProxy()
                    , self.__security.getTipoServidor()
                    , self.__security.getReintentos())
        parametros = {1:("XMLDOC",self.__FG.Remplazar_Caracteres_Xml(self.__CrearXmlAlta()))
                      ,2:("TipoRespuesta","Python")}
        
        if WebService.Enviar(
            "INSERT_XML_IngresoDeArticulosAlStock"
            , "www.osplad.org.ar"
            , parametros, "Python")== True:
            if WebService.Count()> 0 :
                while WebService.BOF()== False and WebService.EOF()== False:
                    self.__IdMovimiento = WebService.Fields("IdMovimiento")
                    WebService.MoveNext()
                return True
            else:
                return False
            
    def IngresarStock(self):
        if self.getPedirNroSeries()== True:
            self.__ValidarNroSeries()
            if self._Son_Validos_Los_Nro_Series()== True:
                if self.__ValidarDistribucion()== True:
                    return self.__IngresarStock()
            else:
                raise Nros_De_Series_Invalidos("Se encontraron nro de series invalidos, verifique por favor")
        else:
            if self.__ValidarDistribucion()== True:
                    return self.__IngresarStock()
            
class Nros_De_Series_Invalidos(Exception):
    """Excepcion: ocurre cuando se encuentran nro de series invalidos
    Parametros:
    -mensaje: mensaje de error"""
    def __init__(self,mensaje):
        self.__Mensaje = mensaje
        self.__ErrorDescripcion = self.__Mensaje
    def __str__(self):
        return repr(self.__ErrorDescripcion)
    
        
